package com.future;

import java.util.Arrays;

/**
 * Description:
 * 给定一个初始元素全部为0，大小为 m*n 的矩阵M以及在M上的一系列更新操作。
 * 操作用二维数组表示，其中的每个操作用一个含有两个正整数a 和 b 的数组表示，含义是将所有符合0 <= i < a 以及 0 <= j < b 的元素M[i][j]的值都增加 1。
 * 在执行给定的一系列操作后，你需要返回矩阵中含有最大整数的元素个数。
 * <p>
 * 示例 1:
 * <p>
 * 输入:
 * m = 3, n = 3
 * operations = [[2,2],[3,3]]
 * 输出: 4
 * 解释:
 * 初始状态, M =
 * [[0, 0, 0],
 * [0, 0, 0],
 * [0, 0, 0]]
 * <p>
 * 执行完操作 [2,2] 后, M =
 * [[1, 1, 0],
 * [1, 1, 0],
 * [0, 0, 0]]
 * <p>
 * 执行完操作 [3,3] 后, M =
 * [[2, 2, 1],
 * [2, 2, 1],
 * [1, 1, 1]]
 * <p>
 * M 中最大的整数是 2, 而且 M 中有4个值为2的元素。因此返回 4。
 * 注意:
 * <p>
 * m 和 n 的范围是[1,40000]。
 * a 的范围是 [1,m]，b 的范围是 [1,n]。
 * 操作数目不超过 10000。
 * <p>
 * <p>
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/range-addition-ii
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 * @author weiruibai.vendor
 * Date: 2021/9/26 17:35
 */
public class Solution_maxcount_598 {

    public static void main(String[] args) {

        int[][] ops = new int[][]{{2, 2}, {3, 3}};
        ops = new int[0][0];
        int m = 3, n = 3;
        int i = maxCount(m, n, ops);
        System.out.println(i);

    }


    /**
     * 答案用这个
     * <p>
     * 思路：谁被加的次数多，谁就最大
     * 此说最多就是：最小的行，最小的列，相乘的面积
     *
     * @param m
     * @param n
     * @param ops
     * @return
     *
     * @see Solution_maxcount_598#maxCount_v2 帮助理解
     */
    public static int maxCount(int m, int n, int[][] ops) {
        if (ops == null || ops.length == 0) {
            // 此时最大是0，个数是数组的总单元个数！！
            return m * n;
        }
        int minRow = 40001;
        int minColum = 40001;
        for (int i = 0; i < ops.length; i++) { // 行
            minRow = Math.min(minRow, ops[i][0]);
            minColum = Math.min(minColum, ops[i][1]);
        }
        return minColum * minRow;
    }

    /**
     * 详细过程
     * <p>
     * 思路：谁被加的次数多，谁就最大
     * 此说最多就是：最小的行，最小的列，相乘的面积
     *
     * @param m
     * @param n
     * @param ops
     * @return
     */
    public static int maxCount_v2(int m, int n, int[][] ops) {
        if (ops == null || ops.length == 0) {
            return m * n;
        }
        int minRow = 40001;
        int minColum = 40001;
        int[][] arr = new int[m][n];
        for (int i = 0; i < ops.length; i++) { // 行
            int row = ops[i][0];
            minRow = Math.min(row, minRow);
            int colum = ops[i][1];
            minColum = Math.min(minColum, colum);
            for (int k = 0; k < row; k++) {
                for (int l = 0; l < colum; l++) {
                    arr[k][l]++;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(Arrays.toString(arr[i]));
        }
        System.out.println("个数：" + minRow * minColum);
        return minRow * minColum;
    }
}
